package com.s7.network.support;


import com.s7.network.exception.ERROR;
import com.s7.network.exception.ExceptionHandle;
import com.s7.network.exception.ResponeThrowable;
import com.s7.network.listener.OnRequestListener;
import com.s7.network.type.typeimpl.ParameterizedTypeImpl;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import io.reactivex.observers.DisposableObserver;
import okhttp3.ResponseBody;

/**
 * 网络请求 观察者
 * 基类
 */
public abstract class BaseObserver<T> extends DisposableObserver<ResponseBody> {

    protected OnRequestListener<T> listener;
    protected Type type;

    public BaseObserver() {
        type = Object.class;
    }

    public BaseObserver(OnRequestListener<T> listener) {
        this.listener = listener;
        // 获取T的类型
        type = this.listener.tClass;
    }

    @Override
    public void onNext(ResponseBody body) {
        onResponseBody(body);
    }

    /**
     * 请求结果处理
     * @param body
     */
    protected abstract void onResponseBody(ResponseBody body);

//    /**
//     * 获取泛型
//     * @return
//     */
//    protected Type getType() {
//        // 判断T的类型是不是List类型
//        if (!(type instanceof Class)) {
//            // 生成List<T> 中的 T
//            Type listType = new ParameterizedTypeImpl(List.class, new Type[]{(
//                    (ParameterizedType)type).getActualTypeArguments()[0]});
//            return listType;
//        }
//        return type;
//    }

    /**
     * 获取泛型
     * @return
     */
    public Type[] getType() {
        // 判断T的类型是不是List类型
        if (!(type instanceof Class)) {
            // 生成List<T> 中的 T
            Type mt = ((ParameterizedType) type).getActualTypeArguments()[0];
            Type listType = new ParameterizedTypeImpl(List.class, new Type[]{mt});
            return new Type[]{listType};
        } else {
            return new Type[]{type};
        }
    }

    protected void onSuccess(T data) {
        if (listener != null) {
            listener.onSuccess(data);
        }
    }

    /**
     * 网络请求未获取到正确的数据
     * @param code
     * @param message
     */
    protected void onUnusual(int code, String message) {
        if (listener != null) {
            listener.onError(new ResponeThrowable(code, message));
        }
    }

    /**
     * 订阅结束
     */
    protected void onEnd() {
    }

    /**
     * 取消订阅
     */
    protected void onCancel() {
        if (!this.isDisposed()) {
            this.dispose();
        }
    }

    @Override
    public void onError(Throwable e) {
        if (listener != null) {
            if(e instanceof Exception){
                //访问获得对应的Exception
                if (listener != null) {
                    listener.onError(ExceptionHandle.handleException(e));
                }
            }else {
                //将Throwable 和 未知错误的status code返回
                if (listener != null) {
                    listener.onError(new ResponeThrowable(e, ERROR.UNKNOWN));
                }
            }
        }
        onEnd();
    }

    @Override
    public void onComplete() {
        onEnd();
    }

}

